const stateArr = {}
const SymbolTimeout = Symbol("Timeout")
const SymbolResolve = Symbol("Resolve")

export default class plugin {
  /**
   * @param name 插件名称
   * @param dsc 插件描述
   * @param handler handler配置
   * @param handler.key handler支持的事件key
   * @param handler.fn handler的处理func
   * @param namespace namespace，设置handler时建议设置
   * @param event 执行事件，默认message
   * @param priority 优先级，数字越小优先级越高，或者 'extended' 表示扩展优先级
   * @param rule
   * @param rule.reg 命令正则
   * @param rule.fnc 命令执行方法
   * @param rule.event 执行事件，默认message
   * @param rule.log  false时不显示执行日志
   * @param rule.permission 权限 master,owner,admin,all
   * @param task
   * @param task.name 定时任务名称
   * @param task.cron 定时任务cron表达式
   * @param task.fnc 定时任务方法名
   * @param task.log  false时不显示执行日志
   */
  constructor({
    name = "your-plugin",
    dsc = "无",
    bypassThrottle = false,
    handler,
    namespace,
    event = "message",
    priority = 5000,
    task = { name: "", fnc: "", cron: "" },
    rule = []
  }) {
    /** 插件名称 */
    this.name = name
    /** 插件描述 */
    this.dsc = dsc
    /** 监听事件，默认message https://oicqjs.github.io/oicq/#events */
    this.event = event
    /** 优先级 */
    this.priority = priority
    /** 定时任务，可以是数组 */
    this.task = task
    /** 命令规则 */
    this.rule = rule
    /** 是否绕过节流 */
    this.bypassThrottle = bypassThrottle
    if (handler) {
      this.handler = handler
      this.namespace = namespace ? namespace : ""
    }
  }

  /**
   * @param msg 发送的消息
   * @param quote 是否引用回复
   * @param data.recallMsg 群聊是否撤回消息，0-120秒，0不撤回
   * @param data.at 是否at用户
   */
  reply(msg = "", quote = false, data = {}) {
    if (!this.e || !this.e.reply || !msg) return false
    return this.e.reply(msg, quote, data)
  }

  conKey(isGroup = false) {
    const selfId = this.e && this.e.self_id ? this.e.self_id : '';
    const groupId = isGroup ? 
      (this.group_id ? this.group_id : (this.e && this.e.group_id ? this.e.group_id : '')) : 
      (this.user_id ? this.user_id : (this.e && this.e.user_id ? this.e.user_id : ''));
    return `${this.name}.${selfId}.${groupId}`
  }

  /**
   * @param type 执行方法
   * @param isGroup 是否群聊
   * @param time 操作时间
   * @param timeout 操作超时回复
   */
  setContext(type, isGroup = false, time = 120, timeout = "操作超时已取消") {
    const key = this.conKey(isGroup)
    if (!stateArr[key]) stateArr[key] = {}
    stateArr[key][type] = this.e
    
    if (time && time > 0) {
      stateArr[key][type][SymbolTimeout] = setTimeout(() => {
        if (!stateArr[key] || !stateArr[key][type]) return;
        
        const state = stateArr[key][type];
        const resolve = state[SymbolResolve];
        
        delete stateArr[key][type]
        if (Object.keys(stateArr[key]).length === 0) delete stateArr[key]
        
        if (resolve) {
          resolve(false)
        } else {
          this.reply(timeout, true)
        }
      }, time * 1000)
    }
    
    return stateArr[key][type]
  }

  getContext(type, isGroup = false) {
    const key = this.conKey(isGroup)
    if (!stateArr[key]) return null
    
    if (type) {
      return stateArr[key][type] ? stateArr[key][type] : null
    }
    return stateArr[key]
  }

  finish(type, isGroup = false) {
    const key = this.conKey(isGroup)
    if (stateArr[key] && stateArr[key][type]) {
      const context = stateArr[key][type];
      
      const timeout = context[SymbolTimeout];
      if (timeout) {
        clearTimeout(timeout);
        delete context[SymbolTimeout];
      }
      
      const resolve = context[SymbolResolve];
      if (resolve) {
        resolve(true);
        delete context[SymbolResolve];
      }
      
      delete stateArr[key][type]
      if (Object.keys(stateArr[key]).length === 0) delete stateArr[key]
    }
  }

  awaitContext(...args) {
    return new Promise(resolve => {
      const context = this.setContext("resolveContext", ...args);
      if (context) {
        context[SymbolResolve] = resolve;
      }
    })
  }

  resolveContext(context) {
    const key = this.conKey(false);
    const storedContext = stateArr[key] && stateArr[key]["resolveContext"];
    const resolve = storedContext && storedContext[SymbolResolve];
    
    this.finish("resolveContext");
    if (resolve && context) {
      resolve(this.e);
    }
  }
}